package org.example.demo1.service;

import io.fabric8.kubernetes.api.model.*;
import io.fabric8.kubernetes.client.Config;
import io.fabric8.kubernetes.client.DefaultKubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClientException;
import io.fabric8.kubernetes.client.dsl.base.PatchContext;
import io.fabric8.kubernetes.client.dsl.base.PatchType;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;
import io.fabric8.kubernetes.api.model.Pod;

import io.fabric8.kubernetes.api.model.apps.Deployment;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.time.ZoneId; // 用于处理时间
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

import java.util.List;
import java.util.stream.Collectors;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

import org.example.demo1.util.KubernetesClientUtil; // 根据你的实际包路径调整

import static org.example.demo1.util.KubernetesClientUtil.testConnection;

@Service
@Slf4j
public class PodTools {
    /*
    1.检查Kubernetes集群整体健康状况
    2.获取指定命名空间的所有Pod状态概览
    3.获取特定Pod的详细信息和状态
    4.获取特定Pod的日志信息，自动处理多容器Pod
    5.识别命名空间中最需要关注的问题Pod
    6.获取集群中的所有命名空间信息
    7.获取集群中所有Pod的概览信息，按命名空间分组显示
    8.重启指定命名空间内的Pod
    9.直接删除指定命名空间内的Pod
    10.获取指定Pod的当前CPU和内存资源使用情况
    11.获取指定Pod的YAML配置
    12.获取指定Pod所在节点的详细信息
    13.获取指定Pod中所有容器的端口信息，包括容器暴露的端口及其协议
    14.检查指定Pod中所有容器的活跃度（Liveness）和就绪性（Readiness）探针的详细配置
    15.尝试修复Pod中容器的镜像拉取失败问题
    16.根据大语言模型(LLM)生成的修改建议（YAML或JSON格式的补丁），对指定的Deployment进行修改。
    17.获取指定Pod的所有Kubernetes事件
    18.尝试修复Pod中容器的镜像拉取失败问题

    1.根据Pod名称（支持部分匹配）获取Pod所在的命名空间。
    2.根据指定的标签（Label）获取Pod的名称和所在的命名空间。
    3.根据给定的字符串，判断它最可能对应的是一个Pod名称、命名空间名称还是一个标签（key=value）


     */
    //private static final String KUBECONFIG_PATH = "E:\\whu-ops\\src\\main\\resources\\templates\\config";
    private static final String DEFAULT_NAMESPACE = "online-boutique";
    //private static final int CONNECTION_TIMEOUT = 10;
    //private static final int REQUEST_TIMEOUT = 15;

    @PostConstruct
    public void init() {
        log.info("🔧 PodTools 初始化完成 - 支持流程化诊断");
    }

    @Tool(description = "获取当前时间")
    public String getCurrentDateTime() {
        log.info("🔧 工具调用: getCurrentDateTime()");
        return LocalDateTime.now().atZone(LocaleContextHolder.getTimeZone().toZoneId()).toString();
    }

    @Tool(description = "步骤1: 检查Kubernetes集群整体健康状况")
    public String checkClusterHealth() {
        log.info("🔧 [步骤1] 集群健康检查");

        try {
            long startTime = System.currentTimeMillis();

            // 使用 KubernetesClientUtil 的 testConnection() 方法来检查连接
            // 如果需要更详细的错误信息，可以根据 KubernetesClientUtil 的实现来捕获
            if (!testConnection()) {
                // testConnection 内部已经记录了错误日志
                return """
                    ❌ **集群连接异常**
                    - 错误信息: 无法建立与Kubernetes集群的连接或kubeconfig文件有问题。
                    - 建议检查: 集群是否启动、网络连接、kubeconfig配置。
                    """;
            }

            // 成功连接后，获取客户端实例
            try (KubernetesClient client = KubernetesClientUtil.getClient()) { // 调用 KubernetesClientUtil 的 getClient()
                String version = client.getKubernetesVersion().getGitVersion();
                long connectionTime = System.currentTimeMillis() - startTime;
                int namespaceCount = client.namespaces().list().getItems().size();
                int nodeCount = client.nodes().list().getItems().size();

                return String.format("""
                    ✅ **集群基础健康状态**
                    - Kubernetes版本: %s
                    - 连接时间: %dms
                    - 节点数量: %d个
                    - 命名空间数量: %d个
                    - 连接状态: 正常
                    """, version, connectionTime, nodeCount, namespaceCount);
            }
        } catch (Exception e) { // 捕获可能从 KubernetesClientUtil.getClient() 抛出的 IOException 等
            log.error("集群健康检查失败: {}", e.getMessage(), e);
            return String.format("""
                ❌ **集群连接异常**
                - 错误信息: %s
                - 建议检查: 集群是否启动、网络连接、kubeconfig配置
                """, e.getMessage());
        }
    }


    @Tool(description = "步骤2: 获取指定命名空间的所有Pod状态概览")
    public String getPodStatusOverview(String namespace) {
        if (namespace == null || namespace.trim().isEmpty()) {
            namespace = DEFAULT_NAMESPACE;
        }

        log.info("🔧 [步骤2] Pod状态概览 - 命名空间: {}", namespace);

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败，无法获取Pod状态";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                List<Pod> podsList = client.pods().inNamespace(namespace).list().getItems();

                if (podsList.isEmpty()) {
                    return String.format("⚠️ 在 %s 命名空间中没有找到Pod", namespace);
                }

                // 统计各种状态的Pod
                long runningPods = podsList.stream().filter(pod -> "Running".equals(pod.getStatus().getPhase())).count();
                long pendingPods = podsList.stream().filter(pod -> "Pending".equals(pod.getStatus().getPhase())).count();
                long failedPods = podsList.stream().filter(pod -> "Failed".equals(pod.getStatus().getPhase())).count();
                long succeededPods = podsList.stream().filter(pod -> "Succeeded".equals(pod.getStatus().getPhase())).count();

                // 识别问题Pod
                List<Pod> problemPods = podsList.stream()
                        .filter(pod -> !isPodHealthy(pod))
                        .collect(Collectors.toList());

                StringBuilder result = new StringBuilder();
                result.append(String.format("""
                    📊 **Pod状态统计** (命名空间: %s)
                    - 总数: %d个
                    - Running: %d个
                    - Pending: %d个
                    - Failed: %d个
                    - Succeeded: %d个
                    
                    """, namespace, podsList.size(), runningPods, pendingPods, failedPods, succeededPods));

                if (problemPods.isEmpty()) {
                    result.append("✅ **状态评估**: 所有Pod运行正常\n");
                } else {
                    result.append(String.format("⚠️ **发现问题Pod**: %d个需要关注\n", problemPods.size()));
                    result.append("**问题Pod列表**:\n");
                    for (Pod pod : problemPods) {
                        String podName = pod.getMetadata().getName();
                        String phase = pod.getStatus().getPhase();
                        String readyStatus = getPodReadyStatus(pod);
                        int restartCount = getRestartCount(pod);

                        result.append(String.format("- %s | 状态: %s | 就绪: %s | 重启: %d次\n",
                                podName, phase, readyStatus, restartCount));
                    }
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取Pod状态概览失败: {}", e.getMessage(), e);
            return String.format("❌ 获取Pod状态失败: %s", e.getMessage());
        }
    }

    @Tool(description = "步骤3: 获取特定Pod的详细信息和状态")
    public String getPodDetailedInfo(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ Pod名称不能为空";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 [步骤3] Pod详细信息 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ Pod %s 在命名空间 %s 中不存在", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("🔍 **Pod详细信息**: %s\n\n", podName));

                // 基本信息
                result.append("**基本信息**:\n");
                result.append(String.format("- 命名空间: %s\n", targetNamespace));
                result.append(String.format("- 状态阶段: %s\n", pod.getStatus().getPhase()));
                result.append(String.format("- 就绪状态: %s\n", getPodReadyStatus(pod)));
                result.append(String.format("- 重启次数: %d\n", getRestartCount(pod)));
                result.append(String.format("- 节点: %s\n", pod.getSpec().getNodeName() != null ? pod.getSpec().getNodeName() : "未分配"));
                result.append(String.format("- Pod IP: %s\n", pod.getStatus().getPodIP() != null ? pod.getStatus().getPodIP() : "未分配"));
                result.append("\n");

                // 容器状态
                if (pod.getStatus().getContainerStatuses() != null) {
                    result.append("**容器状态**:\n");
                    pod.getStatus().getContainerStatuses().forEach(containerStatus -> {
                        result.append(String.format("- %s: ready=%s, restarts=%d\n",
                                containerStatus.getName(),
                                containerStatus.getReady(),
                                containerStatus.getRestartCount() != null ? containerStatus.getRestartCount() : 0));

                        if (containerStatus.getState() != null) {
                            if (containerStatus.getState().getWaiting() != null) {
                                result.append(String.format("  等待原因: %s\n", containerStatus.getState().getWaiting().getReason()));
                            }
                            if (containerStatus.getState().getTerminated() != null) {
                                result.append(String.format("  终止原因: %s\n", containerStatus.getState().getTerminated().getReason()));
                            }
                        }
                    });
                    result.append("\n");
                }

                // Pod条件
                if (pod.getStatus().getConditions() != null) {
                    result.append("**Pod条件**:\n");
                    for (PodCondition condition : pod.getStatus().getConditions()) {
                        String status = "True".equals(condition.getStatus()) ? "✅" : "❌";
                        result.append(String.format("- %s %s: %s\n", status, condition.getType(), condition.getStatus()));
                        if (condition.getMessage() != null && !condition.getMessage().isEmpty()) {
                            result.append(String.format("  消息: %s\n", condition.getMessage()));
                        }
                    }
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取Pod详细信息失败: {}", e.getMessage(), e);
            return String.format("❌ 获取Pod详细信息失败: %s", e.getMessage());
        }
    }

    @Tool(description = "步骤4: 获取特定Pod的日志信息，自动处理多容器Pod")
    public String getPodLogs(String podName, String namespace, String container) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ Pod名称不能为空";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 [步骤4] Pod日志获取 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败，无法获取日志";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 首先获取Pod信息，查看有哪些容器
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();
                if (pod == null) {
                    return String.format("❌ Pod %s 在命名空间 %s 中不存在", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **Pod日志分析**: %s\n\n", podName));

                // 获取所有容器
                List<String> containerNames = new ArrayList<>();
                if (pod.getSpec().getContainers() != null) {
                    containerNames.addAll(pod.getSpec().getContainers().stream()
                            .map(c -> c.getName())
                            .collect(Collectors.toList()));
                }

                if (containerNames.isEmpty()) {
                    return "⚠️ Pod中没有找到容器";
                }

                result.append(String.format("**发现容器**: %s\n\n", String.join(", ", containerNames)));

                // 如果指定了容器，只获取该容器的日志
                if (container != null && !container.trim().isEmpty()) {
                    if (containerNames.contains(container)) {
                        String logs = getContainerLogs(client, targetNamespace, podName, container);
                        result.append(String.format("**容器 %s 的日志**:\n", container));
                        result.append(logs);
                    } else {
                        result.append(String.format("❌ 指定的容器 %s 不存在，可用容器: %s", container, String.join(", ", containerNames)));
                    }
                } else {
                    // 获取所有容器的日志，但重点关注应用容器
                    for (String containerName : containerNames) {
                        // 跳过istio相关的sidecar容器，专注于业务容器
                        if (containerName.equals("istio-proxy") || containerName.equals("istio-init")) {
                            continue;
                        }

                        result.append(String.format("**容器 %s 的日志**:\n", containerName));
                        String logs = getContainerLogs(client, targetNamespace, podName, containerName);
                        result.append(logs).append("\n\n");
                    }

                    // 如果只有sidecar容器，也要显示
                    if (result.toString().contains("**容器") == false) {
                        String mainContainer = containerNames.get(0);
                        result.append(String.format("**容器 %s 的日志**:\n", mainContainer));
                        String logs = getContainerLogs(client, targetNamespace, podName, mainContainer);
                        result.append(logs);
                    }
                }

                return result.toString();

            }
        } catch (Exception e) {
            log.error("获取Pod {} 日志时发生异常: {}", podName, e.getMessage(), e);
            return String.format("❌ 获取Pod %s 日志失败: %s", podName, e.getMessage());
        }
    }

    private String getContainerLogs(KubernetesClient client, String namespace, String podName, String containerName) {
        try {
            String logs = client.pods()
                    .inNamespace(namespace)
                    .withName(podName)
                    .inContainer(containerName)
                    .tailingLines(30)  // 获取最后30行
                    .getLog();

            if (logs == null || logs.trim().isEmpty()) {
                return String.format("⚠️ 容器 %s 没有可用的日志\n", containerName);
            }

            // 分析日志
            String[] logLines = logs.split("\n");
            long errorCount = 0;
            StringBuilder criticalErrors = new StringBuilder();

            for (String line : logLines) {
                String lowerLine = line.toLowerCase();
                if (lowerLine.contains("error") || lowerLine.contains("exception") || lowerLine.contains("fatal")) {
                    errorCount++;
                    if (criticalErrors.length() < 300) {
                        criticalErrors.append("  - ").append(line.trim()).append("\n");
                    }
                }
            }

            StringBuilder containerResult = new StringBuilder();
            if (errorCount > 0) {
                containerResult.append(String.format("⚠️ 发现 %d 个错误:\n", errorCount));
                containerResult.append(criticalErrors.toString()).append("\n");
            }

            containerResult.append("```\n");
            containerResult.append(logs);
            containerResult.append("\n```\n");

            return containerResult.toString();

        } catch (Exception e) {
            return String.format("❌ 获取容器 %s 日志失败: %s\n", containerName, e.getMessage());
        }
    }

    @Tool(description = "步骤5: 识别命名空间中最需要关注的问题Pod")
    public String identifyProblemPods(String namespace) {
        if (namespace == null || namespace.trim().isEmpty()) {
            namespace = DEFAULT_NAMESPACE;
        }

        log.info("🔧 [步骤5] 识别问题Pod - 命名空间: {}", namespace);

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                List<Pod> podsList = client.pods().inNamespace(namespace).list().getItems();

                if (podsList.isEmpty()) {
                    return String.format("⚠️ 在 %s 命名空间中没有找到Pod", namespace);
                }

                // 按问题严重程度排序
                List<Pod> problemPods = podsList.stream()
                        .filter(pod -> !isPodHealthy(pod))
                        .sorted((pod1, pod2) -> {
                            // 按严重程度排序：Failed > Pending > 高重启次数 > 未就绪
                            int score1 = getProblemScore(pod1);
                            int score2 = getProblemScore(pod2);
                            return Integer.compare(score2, score1); // 降序
                        })
                        .limit(5) // 最多返回5个最严重的问题
                        .collect(Collectors.toList());

                if (problemPods.isEmpty()) {
                    return String.format("✅ 命名空间 %s 中所有Pod运行正常，无需特别关注", namespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("🚨 **问题Pod识别结果** (命名空间: %s)\n\n", namespace));
                result.append(String.format("发现 %d 个需要关注的Pod（按严重程度排序）:\n\n", problemPods.size()));

                for (int i = 0; i < problemPods.size(); i++) {
                    Pod pod = problemPods.get(i);
                    String podName = pod.getMetadata().getName();
                    String phase = pod.getStatus().getPhase();
                    String readyStatus = getPodReadyStatus(pod);
                    int restartCount = getRestartCount(pod);

                    String severity = getProblemSeverity(pod);

                    result.append(String.format("**%d. %s** %s\n", i + 1, podName, severity));
                    result.append(String.format("   - 状态: %s\n", phase));
                    result.append(String.format("   - 就绪: %s\n", readyStatus));
                    result.append(String.format("   - 重启次数: %d\n", restartCount));
                    result.append(String.format("   - 建议: %s\n\n", getRecommendation(pod)));
                }

                // 推荐下一步操作
                Pod mostCritical = problemPods.get(0);
                result.append("**建议下一步操作**:\n");
                result.append(String.format("优先检查 '%s'，这是最需要关注的Pod\n", mostCritical.getMetadata().getName()));

                return result.toString();
            }
        } catch (Exception e) {
            log.error("识别问题Pod失败: {}", e.getMessage(), e);
            return String.format("❌ 识别问题Pod失败: %s", e.getMessage());
        }
    }

    @Tool(description = "获取集群中的所有命名空间信息")
    public String getAllNamespaces() {
        log.info("🔧 工具调用: getAllNamespaces()");

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败，无法获取命名空间";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                var namespaces = client.namespaces().list().getItems();

                if (namespaces.isEmpty()) {
                    return "⚠️ 集群中没有找到命名空间";
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **集群命名空间列表** (共 %d 个)\n\n", namespaces.size()));

                // 按状态分类统计
                long activeNamespaces = namespaces.stream()
                        .filter(ns -> "Active".equals(ns.getStatus().getPhase()))
                        .count();
                long terminatingNamespaces = namespaces.stream()
                        .filter(ns -> "Terminating".equals(ns.getStatus().getPhase()))
                        .count();

                result.append(String.format("**状态统计**:\n"));
                result.append(String.format("- Active: %d个\n", activeNamespaces));
                result.append(String.format("- Terminating: %d个\n", terminatingNamespaces));
                result.append("\n");

                result.append("**详细列表**:\n");
                for (var namespace : namespaces) {
                    String name = namespace.getMetadata().getName();
                    String phase = namespace.getStatus().getPhase();
                    String creationTime = namespace.getMetadata().getCreationTimestamp();

                    String statusIcon = "Active".equals(phase) ? "✅" : "⚠️";
                    result.append(String.format("- %s **%s** | 状态: %s | 创建时间: %s\n",
                            statusIcon, name, phase, creationTime));
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取所有命名空间失败: {}", e.getMessage(), e);
            return String.format("❌ 获取命名空间列表失败: %s", e.getMessage());
        }
    }

    @Tool(description = "获取集群中所有Pod的概览信息，按命名空间分组显示")
    public String getAllPodsOverview() {
        log.info("🔧 工具调用: getAllPodsOverview()");

        try {
            if (!testConnection()) {
                return "❌ 集群连接失败，无法获取Pod信息";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 获取所有Pod
                var allPods = client.pods().inAnyNamespace().list().getItems();

                if (allPods.isEmpty()) {
                    return "⚠️ 集群中没有找到任何Pod";
                }

                // 按命名空间分组
                var podsByNamespace = allPods.stream()
                        .collect(Collectors.groupingBy(pod -> pod.getMetadata().getNamespace()));

                StringBuilder result = new StringBuilder();
                result.append(String.format("🌐 **集群Pod全景概览** (共 %d 个Pod，分布在 %d 个命名空间)\n\n",
                        allPods.size(), podsByNamespace.size()));

                // 全局统计
                long totalRunning = allPods.stream().filter(pod -> "Running".equals(pod.getStatus().getPhase())).count();
                long totalPending = allPods.stream().filter(pod -> "Pending".equals(pod.getStatus().getPhase())).count();
                long totalFailed = allPods.stream().filter(pod -> "Failed".equals(pod.getStatus().getPhase())).count();
                long totalSucceeded = allPods.stream().filter(pod -> "Succeeded".equals(pod.getStatus().getPhase())).count();
                long totalProblem = allPods.stream().filter(pod -> !isPodHealthy(pod)).count();

                result.append("**全局统计**:\n");
                result.append(String.format("- Running: %d个\n", totalRunning));
                result.append(String.format("- Pending: %d个\n", totalPending));
                result.append(String.format("- Failed: %d个\n", totalFailed));
                result.append(String.format("- Succeeded: %d个\n", totalSucceeded));
                result.append(String.format("- 问题Pod: %d个\n\n", totalProblem));

                // 按命名空间详细显示
                result.append("**按命名空间分组**:\n");

                // 按Pod数量降序排列命名空间
                var sortedNamespaces = podsByNamespace.entrySet().stream()
                        .sorted((e1, e2) -> Integer.compare(e2.getValue().size(), e1.getValue().size()))
                        .collect(Collectors.toList());

                for (var entry : sortedNamespaces) {
                    String namespace = entry.getKey();
                    var pods = entry.getValue();

                    long nsRunning = pods.stream().filter(pod -> "Running".equals(pod.getStatus().getPhase())).count();
                    long nsPending = pods.stream().filter(pod -> "Pending".equals(pod.getStatus().getPhase())).count();
                    long nsFailed = pods.stream().filter(pod -> "Failed".equals(pod.getStatus().getPhase())).count();
                    long nsProblem = pods.stream().filter(pod -> !isPodHealthy(pod)).count();

                    String healthIcon = nsProblem == 0 ? "✅" : (nsProblem > pods.size() / 2 ? "🔴" : "⚠️");

                    result.append(String.format("\n%s **%s** (%d个Pod)\n", healthIcon, namespace, pods.size()));
                    result.append(String.format("   Running: %d | Pending: %d | Failed: %d | 问题: %d\n",
                            nsRunning, nsPending, nsFailed, nsProblem));

                    // 如果有问题Pod，列出前3个
                    if (nsProblem > 0) {
                        var problemPods = pods.stream()
                                .filter(pod -> !isPodHealthy(pod))
                                .limit(3)
                                .map(pod -> pod.getMetadata().getName())
                                .collect(Collectors.toList());
                        result.append(String.format("   问题Pod: %s%s\n",
                                String.join(", ", problemPods),
                                nsProblem > 3 ? String.format(" (还有%d个...)", nsProblem - 3) : ""));
                    }
                }

                if (totalProblem > 0) {
                    result.append(String.format("\n💡 **建议**: 发现 %d 个问题Pod，建议使用 identifyProblemPods 方法进一步分析", totalProblem));
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取所有Pod概览失败: {}", e.getMessage(), e);
            return String.format("❌ 获取所有Pod概览失败: %s", e.getMessage());
        }
    }

    @Tool(description = "重启指定命名空间内的Pod。这对于解决短暂的Pod故障或应用问题非常有用。")
    public String restartPod(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? "default" : namespace; // 假设默认命名空间是 "default"
        log.info("🔧 尝试重启 Pod - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法重启 Pod。请检查网络和 kubeconfig 配置。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod podToDelete = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (podToDelete == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**，无法重启。", podName, targetNamespace);
                }

                String oldPodUid = podToDelete.getMetadata().getUid(); // 记录旧 Pod 的 UID

                // 执行删除操作，Fabric8 6.10.0 的 delete() 返回 List<StatusDetails>
                List<StatusDetails> deleteStatusDetails = client.pods().inNamespace(targetNamespace).withName(podName).delete();

                // 验证 Pod 是否已被删除并重新创建
                // 等待足够的时间，让 Kubernetes 处理删除请求，并让其控制器有机会重新创建 Pod
                Thread.sleep(3000); // 增加等待时间至 3 秒，确保 K8s 有足够时间响应

                Pod recreatedPod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (recreatedPod == null) {
                    // 情况1: Pod 彻底消失 (可能不是由 Deployment/StatefulSet 管理的 Pod)
                    return String.format("✅ **已成功请求删除 Pod '%s' (在 %s 命名空间)**。Pod 已从集群中移除。", podName, targetNamespace);
                } else if (!recreatedPod.getMetadata().getUid().equals(oldPodUid)) {
                    // 情况2: Pod 被重新创建 (UID 不同)，说明重启成功
                    return String.format("✅ **Pod '%s' (在 %s 命名空间) 已成功重启**。Pod 已被替换为新的实例。", podName, targetNamespace);
                } else {
                    // 情况3: Pod 仍然存在且 UID 相同，说明删除未成功或 Pod 正在终止中
                    String detailInfo = "";
                    if (deleteStatusDetails != null && !deleteStatusDetails.isEmpty()) {
                        // 在 6.10.0 中，StatusDetails 通常只有 kind, name, uid
                        StatusDetails detail = deleteStatusDetails.get(0);
                        detailInfo = String.format(" (删除请求针对: **%s/%s**)", detail.getKind(), detail.getName());
                    }
                    return String.format("⚠️ **无法确认 Pod '%s' 是否成功重启**。旧 Pod 仍在存在或未被新的 Pod 替换%s。请稍后手动检查 Pod 状态。", podName, detailInfo);
                }
            }
        } catch (KubernetesClientException e) {
            log.error("重启 Pod {} 失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **重启 Pod '%s' 失败**: %s", podName, e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新中断线程
            log.error("重启 Pod {} 过程中线程被中断: {}", podName, e.getMessage(), e);
            return String.format("❌ **重启 Pod '%s' 过程中线程被中断**，请重试: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("重启 Pod {} 时发生未知错误: {}", podName, e.getMessage(), e);
            return String.format("❌ **重启 Pod '%s' 时发生未知错误**: %s", podName, e.getMessage());
        }
    }

    @Tool(description = "直接删除指定命名空间内的Pod。**请谨慎使用，删除后Pod可能不会被自动重建，除非它由Deployment或StatefulSet管理。**")
    public String deletePod(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? "default" : namespace; // 假设默认命名空间是 "default"
        log.warn("🚨 尝试删除 Pod - {}:{}", targetNamespace, podName); // 对删除操作使用 warn 级别日志

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法删除 Pod。请检查网络和 kubeconfig 配置。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod podToDelete = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (podToDelete == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**，无法删除。", podName, targetNamespace);
                }

                // 执行删除操作
                List<StatusDetails> deleteStatusDetails = client.pods().inNamespace(targetNamespace).withName(podName).delete();

                // 验证 Pod 是否已被删除 (更可靠的检查)
                // 等待一小段时间，让 Kubernetes 处理删除请求
                Thread.sleep(2000); // 2 秒

                Pod checkPod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (checkPod == null) {
                    // 如果 Pod 完全消失了，说明删除成功。
                    String detailInfo = "";
                    if (deleteStatusDetails != null && !deleteStatusDetails.isEmpty()) {
                        StatusDetails detail = deleteStatusDetails.get(0);
                        detailInfo = String.format(" (被删除请求处理: **%s/%s**)", detail.getKind(), detail.getName());
                    }
                    return String.format("✅ **已成功删除 Pod '%s' (在 %s 命名空间)**。%s", podName, targetNamespace, detailInfo);
                } else {
                    // 如果 Pod 仍然存在，说明删除未成功或 Pod 正在终止中
                    String detailInfo = "";
                    if (deleteStatusDetails != null && !deleteStatusDetails.isEmpty()) {
                        StatusDetails detail = deleteStatusDetails.get(0);
                        detailInfo = String.format(" (删除请求针对: **%s/%s**)", detail.getKind(), detail.getName());
                    }
                    return String.format("⚠️ **无法确认 Pod '%s' 是否已完全删除**。Pod 仍在集群中%s。请稍后手动检查 Pod 状态。", podName, detailInfo);
                }
            }
        } catch (KubernetesClientException e) {
            log.error("删除 Pod {} 失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **删除 Pod '%s' 失败**: %s", podName, e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 重新中断线程
            log.error("删除 Pod {} 过程中线程被中断: {}", podName, e.getMessage(), e);
            return String.format("❌ **删除 Pod '%s' 过程中线程被中断**，请重试: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("删除 Pod {} 时发生未知错误: {}", podName, e.getMessage(), e);
            return String.format("❌ **删除 Pod '%s' 时发生未知错误**: %s", podName, e.getMessage());
        }
    }



    @Tool(description = "获取指定Pod的YAML配置。这对于检查Pod的定义（如资源限制、环境变量、挂载卷和探针设置）是否正确非常有用。")
    public String getPodConfiguration(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 获取 Pod 配置 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 配置。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                // 使用 Jackson 库将 Pod 对象序列化为 YAML 字符串
                // Fabric8 客户端内部使用 Jackson
                ObjectMapper mapper = new ObjectMapper(new YAMLFactory()
                        .disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER)); // 不写入 "---" 文档开始标记

                String yamlConfig = mapper.writeValueAsString(pod);

                StringBuilder result = new StringBuilder();
                result.append(String.format("📄 **Pod YAML 配置**: %s (命名空间: %s)\n\n", podName, targetNamespace));
                result.append("```yaml\n");
                result.append(yamlConfig);
                result.append("\n```");

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取 Pod {} 配置失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 配置失败**: %s", podName, e.getMessage());
        }
    }

    @Tool(description = "获取指定Pod所在节点的详细信息，包括节点状态、资源容量、已分配资源以及健康状况。")
    public String getNodeInfoForPod(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 获取 Pod 所在节点信息 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法获取节点信息。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                String nodeName = pod.getSpec().getNodeName();
                if (nodeName == null || nodeName.isEmpty()) {
                    return String.format("⚠️ **Pod '%s' (命名空间: %s) 尚未调度到任何节点**。", podName, targetNamespace);
                }

                Node node = client.nodes().withName(nodeName).get();

                if (node == null) {
                    return String.format("❌ **Pod '%s' 所在的节点 '%s' 不存在或无法访问**。", podName, nodeName);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **节点信息**: %s (Pod: %s)\n\n", nodeName, podName));

                result.append("**基本信息**:\n");
                result.append(String.format("- **节点名称**: %s\n", nodeName));
                result.append(String.format("- **节点 IP**: %s\n", node.getStatus().getAddresses().stream()
                        .filter(addr -> "InternalIP".equals(addr.getType()))
                        .map(addr -> addr.getAddress())
                        .findFirst().orElse("N/A")));
                result.append(String.format("- **操作系统**: %s / %s\n", node.getStatus().getNodeInfo().getOperatingSystem(), node.getStatus().getNodeInfo().getOsImage()));
                result.append(String.format("- **Kubernetes 版本**: %s\n", node.getStatus().getNodeInfo().getKubeletVersion()));
                result.append("\n");

                // 节点状态 (Conditions)
                if (node.getStatus().getConditions() != null && !node.getStatus().getConditions().isEmpty()) {
                    result.append("**节点健康状况**:\n");
                    for (NodeCondition condition : node.getStatus().getConditions()) {
                        String statusIcon = "True".equals(condition.getStatus()) ? "✅" : "❌";
                        result.append(String.format("- %s **%s**: %s (原因: %s, 消息: %s)\n",
                                statusIcon, condition.getType(), condition.getStatus(),
                                condition.getReason() != null ? condition.getReason() : "N/A",
                                condition.getMessage() != null ? condition.getMessage() : "N/A"));
                    }
                    result.append("\n");
                }

                // 资源容量 (Capacity)
                if (node.getStatus().getCapacity() != null) {
                    result.append("**资源容量 (Capacity)**:\n");
                    result.append(String.format("- CPU: %s\n", convertCpuUnit(node.getStatus().getCapacity().get("cpu") != null ? node.getStatus().getCapacity().get("cpu").getAmount() : "N/A")));
                    result.append(String.format("- 内存: %s\n", convertMemoryUnit(node.getStatus().getCapacity().get("memory") != null ? node.getStatus().getCapacity().get("memory").getAmount() : "N/A")));
                    result.append(String.format("- Pods: %s\n", node.getStatus().getCapacity().get("pods") != null ? node.getStatus().getCapacity().get("pods").getAmount() : "N/A"));
                    result.append("\n");
                }

                // 已分配资源 (Allocatable) - 通常是实际可用于 Pod 的资源
                if (node.getStatus().getAllocatable() != null) {
                    result.append("**可分配资源 (Allocatable)**:\n");
                    result.append(String.format("- CPU: %s\n", convertCpuUnit(node.getStatus().getAllocatable().get("cpu") != null ? node.getStatus().getAllocatable().get("cpu").getAmount() : "N/A")));
                    result.append(String.format("- 内存: %s\n", convertMemoryUnit(node.getStatus().getAllocatable().get("memory") != null ? node.getStatus().getAllocatable().get("memory").getAmount() : "N/A")));
                    result.append(String.format("- Pods: %s\n", node.getStatus().getAllocatable().get("pods") != null ? node.getStatus().getAllocatable().get("pods").getAmount() : "N/A"));
                    result.append("\n");
                }

                // 计算节点资源使用率 (需要 Metrics Server 或其他途径获取) - 此处仅展示容量，实际使用率需要通过 top() API 获取节点指标
                // Fabric8 客户端的 top().nodes().metrics() 可以获取节点使用情况，但与此函数分开，可以作为另一个工具提供。
                result.append("💡 **提示**: 如需获取节点资源实际使用率，请使用相应的节点指标工具（若可用）。\n");


                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取 Pod {} 所在节点信息失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 所在节点信息失败**: %s", podName, e.getMessage());
        }
    }



    @Tool(description = "获取指定Pod中所有容器的端口信息，包括容器暴露的端口及其协议。这有助于调试网络连通性和服务暴露问题。")
    public String getContainerPortInfo(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 获取 Pod 容器端口信息 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 容器端口信息。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **Pod 容器端口信息**: %s (命名空间: %s)\n\n", podName, targetNamespace));

                if (pod.getSpec().getContainers() != null && !pod.getSpec().getContainers().isEmpty()) {
                    boolean foundPorts = false;
                    for (io.fabric8.kubernetes.api.model.Container container : pod.getSpec().getContainers()) {
                        if (container.getPorts() != null && !container.getPorts().isEmpty()) {
                            foundPorts = true;
                            result.append(String.format("**容器 '%s' 暴露的端口**:\n", container.getName()));
                            for (ContainerPort port : container.getPorts()) {
                                result.append(String.format("- 端口: %d | 名称: %s | 协议: %s | 主机端口: %d\n",
                                        port.getContainerPort(),
                                        port.getName() != null ? port.getName() : "N/A",
                                        port.getProtocol() != null ? port.getProtocol() : "TCP",
                                        port.getHostPort() != null ? port.getHostPort() : 0));
                            }
                            result.append("\n");
                        }
                    }
                    if (!foundPorts) {
                        result.append("⚠️ **此 Pod 中的所有容器均未明确暴露端口**。\n");
                    }
                } else {
                    result.append("⚠️ **Pod 中没有找到容器**。\n");
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("获取 Pod {} 容器端口信息失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 容器端口信息失败**: %s", podName, e.getMessage());
        }
    }

    @Tool(description = "检查指定Pod中所有容器的活跃度（Liveness）和就绪性（Readiness）探针的详细配置。探针配置不当是导致Pod重启或无法就绪的常见原因。")
    public String checkLivenessReadinessProbes(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔧 检查 Pod 活跃度/就绪性探针 - {}:{}", targetNamespace, podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法检查 Pod 探针配置。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **Pod 探针配置**: %s (命名空间: %s)\n\n", podName, targetNamespace));

                if (pod.getSpec().getContainers() != null && !pod.getSpec().getContainers().isEmpty()) {
                    boolean foundProbes = false;
                    for (io.fabric8.kubernetes.api.model.Container container : pod.getSpec().getContainers()) {
                        result.append(String.format("--- **容器 '%s'** ---\n", container.getName()));

                        // Liveness Probe
                        Probe livenessProbe = container.getLivenessProbe();
                        if (livenessProbe != null) {
                            foundProbes = true;
                            result.append("  **活跃度探针 (Liveness Probe)**:\n");
                            result.append(formatProbeDetails(livenessProbe));
                        } else {
                            result.append("  - 活跃度探针: 未配置\n");
                        }

                        // Readiness Probe
                        Probe readinessProbe = container.getReadinessProbe();
                        if (readinessProbe != null) {
                            foundProbes = true;
                            result.append("  **就绪性探针 (Readiness Probe)**:\n");
                            result.append(formatProbeDetails(readinessProbe));
                        } else {
                            result.append("  - 就绪性探针: 未配置\n");
                        }
                        result.append("\n"); // Add a newline for readability between containers
                    }
                    if (!foundProbes) {
                        result.append("⚠️ **此 Pod 中的所有容器均未配置活跃度或就绪性探针**。\n");
                    }
                } else {
                    result.append("⚠️ **Pod 中没有找到容器**。\n");
                }

                return result.toString();
            }
        } catch (Exception e) {
            log.error("检查 Pod {} 探针配置失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **检查 Pod '%s' 探针配置失败**: %s", podName, e.getMessage());
        }
    }

    /**
     * 根据大语言模型(LLM)生成的修改建议对 Deployment 进行修改。
     * 此工具会先执行安全预检（Dry-Run）来验证建议的有效性，通过后才会实际应用变更。
     */
    // 假设 KubernetesClientUtil, testConnection, DEFAULT_NAMESPACE, @Tool 等都已正确定义
// import ...

    /**
     * 根据大语言模型(LLM)生成的修改建议对 Deployment 进行修改。
     * 此工具会先执行安全预检（Dry-Run）来验证建议的有效性，通过后才会实际应用变更。
     */
    @Tool(description = "根据大语言模型(LLM)生成的修改建议（YAML或JSON格式的补丁），对指定的Deployment进行修改。此工具会先执行安全预检（Dry-Run）来验证建议的有效性，通过后才会实际应用变更。")
    public String applyLlmSuggestedDeploymentModification(String deploymentName, String namespace, String llmGeneratedPayload) {
        final Logger log = LoggerFactory.getLogger(this.getClass());

        // 1. 参数校验
        if (deploymentName == null || deploymentName.trim().isEmpty()) {
            return "❌ **Deployment 名称不能为空**。";
        }
        if (llmGeneratedPayload == null || llmGeneratedPayload.trim().isEmpty()) {
            return "❌ **大模型生成的修改建议 (llmGeneratedPayload) 内容不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? "default" : namespace; // 使用 "default" 作为常量
        log.info("⚙️ 接收到针对 Deployment '{}' (命名空间: {}) 的AI修改建议，开始处理...", deploymentName, targetNamespace);

        try {
            // 2. 检查与集群的连接
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法执行任何操作。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 3. 检查 Deployment 是否存在
                if (client.apps().deployments().inNamespace(targetNamespace).withName(deploymentName).get() == null) {
                    return String.format("❌ **Deployment '%s' 在命名空间 '%s' 中不存在**，无法应用修改。", deploymentName, targetNamespace);
                }

                // 4. [核心安全特性] 执行服务端安全预检 (Server-side Dry-Run)
                log.info("🛡️ 对 Deployment '{}' 执行安全预检 (Server-side Dry-Run)...", deploymentName);
                try {
                    // ==========【最终错误修复】==========
                    // 根据编译器错误，withDryRun 方法需要一个 List<String> 类型的参数。
                    // 我们使用 Collections.singletonList("All") 来创建一个符合要求的列表。
                    PatchContext dryRunPatchContext = new PatchContext.Builder()
                            .withPatchType(PatchType.STRATEGIC_MERGE)
                            .withDryRun(Collections.singletonList("All")) // <--- 关键修改
                            .build();

                    client.apps().deployments().inNamespace(targetNamespace).withName(deploymentName).patch(dryRunPatchContext, llmGeneratedPayload);
                    log.info("✅ 安全预检通过。AI生成的修改建议有效。");

                } catch (KubernetesClientException e) {
                    log.error("🛡️❌ 安全预检失败! Deployment: '{}'. 错误: {}", deploymentName, e.getMessage());
                    String validationError = e.getCause() != null ? e.getCause().getMessage() : e.getMessage();
                    return String.format("❌ **AI建议校验失败 (Dry-Run)**: %s\n\n请修正你的修改建议。错误可能源于无效的字段、错误的值或格式问题。", validationError);
                }

                // 5. 应用实际变更 (因为预检已通过)
                log.info("🚀 安全预检通过，开始向 Deployment '{}' 应用实际变更...", deploymentName);

                PatchContext actualPatchContext = new PatchContext.Builder()
                        .withPatchType(PatchType.STRATEGIC_MERGE)
                        .build();

                client.apps().deployments().inNamespace(targetNamespace).withName(deploymentName).patch(actualPatchContext, llmGeneratedPayload);

                return String.format("✅ **已成功向 Deployment '%s' (在 %s 命名空间) 应用AI修改建议**。变更已通过预检，请观察其状态以确认变更已生效。", deploymentName, targetNamespace);
            }
        } catch (KubernetesClientException e) {
            log.error("向 Deployment {} 应用修改时发生Kubernetes客户端异常: {}", deploymentName, e.getMessage(), e);
            String errorDetails = e.getCause() != null ? e.getCause().getMessage() : e.getMessage();
            return String.format("❌ **向 Deployment '%s' 应用修改失败**: %s\n\n即使通过了预检，也可能因权限或瞬时集群问题导致最终失败。", deploymentName, errorDetails);
        } catch (Exception e) {
            log.error("向 Deployment {} 应用修改时发生未知错误: {}", deploymentName, e.getMessage(), e);
            return String.format("❌ **向 Deployment '%s' 应用修改时发生未知错误**: %s", deploymentName, e.getMessage());
        }
    }

    @Tool(description = "获取指定Pod的所有Kubernetes事件。这些事件记录了Pod的生命周期中发生的重要活动，包括调度、拉取镜像、启动、终止以及任何错误或警告，对于诊断Pod故障至关重要。")
    public String getPodEvents(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔍 获取 Pod '{}' 的 Kubernetes 事件", podName);

        try {
            if (!testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 事件。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();
                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                // 通过 involvedObject.name 过滤事件，仅获取与该 Pod 直接相关的事件
                List<Event> events = client.v1().events().inNamespace(targetNamespace)
                        .withField("involvedObject.name", podName)
                        .list()
                        .getItems();

                if (events.isEmpty()) {
                    return String.format("ℹ️ **Pod '%s' (在 %s 命名空间) 没有找到任何相关事件**。", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **Pod 事件列表**: %s (命名空间: %s)\n\n", podName, targetNamespace));

                // 按时间倒序排序事件，以便查看最新事件
                events.sort(Comparator.comparing(Event::getLastTimestamp).reversed());

                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

                for (Event event : events) {
                    String type = event.getType() != null ? event.getType() : "Normal"; // Type: Normal, Warning
                    String reason = event.getReason() != null ? event.getReason() : "N/A";
                    String message = event.getMessage() != null ? event.getMessage() : "N/A";
                    String source = (event.getSource() != null && event.getSource().getComponent() != null) ? event.getSource().getComponent() : "N/A";
                    String lastTimestamp = (event.getLastTimestamp() != null) ?
                            ZonedDateTime.parse(event.getLastTimestamp()).withZoneSameInstant(ZoneId.systemDefault()).format(formatter) : "N/A";

                    result.append(String.format("- **时间**: %s\n", lastTimestamp));
                    result.append(String.format("  - **类型**: %s\n", type));
                    result.append(String.format("  - **原因**: %s\n", reason));
                    result.append(String.format("  - **消息**: %s\n", message));
                    result.append(String.format("  - **来源**: %s\n", source));
                    result.append(String.format("  - **计数**: %d 次\n", event.getCount() != null ? event.getCount() : 1));
                    result.append("\n");
                }

                return result.toString();
            }
        } catch (KubernetesClientException e) {
            log.error("获取 Pod {} 事件失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 事件失败**: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("获取 Pod {} 事件时发生未知错误: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 事件时发生未知错误**: %s", podName, e.getMessage());
        }
    }

    /**
     * 尝试修复Pod中容器的镜像拉取失败问题。
     * 通过更新指定Pod中容器的镜像名称来解决镜像不存在、名称错误或版本问题。
     * 请注意，此操作会触发Pod重建/重启以拉取新镜像。
     *
     * @param podName Pod的名称。
     * @param namespace Pod所在的命名空间。
     * @param containerName 需要修改镜像的容器名称。
     * @param newImageName 新的镜像名称（例如 "nginx:1.23.0" 或 "myregistry/myimage:latest"）。
     * @return 操作结果的消息。
     */
    @Tool(description = "尝试修复Pod中容器的镜像拉取失败问题。通过更新指定Pod中容器的镜像名称来解决镜像不存在、名称错误或版本问题。请注意，此操作会触发Pod重建/重启以拉取新镜像。")
    public String fixImagePullBackOff(String podName, String namespace, String containerName, String newImageName) {
        if (podName == null || podName.trim().isEmpty() || containerName == null || containerName.trim().isEmpty() ||
                newImageName == null || newImageName.trim().isEmpty()) {
            return "❌ **Pod 名称、容器名称和新的镜像名称都不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🔄 尝试修复 Pod '{}' (命名空间: {}) 中容器 '{}' 的镜像拉取问题，新镜像为: '{}'",
                podName, targetNamespace, containerName, newImageName);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法修改 Pod 镜像。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 1. 获取 Pod 的最新状态
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                boolean containerFound = false;
                for (Container container : pod.getSpec().getContainers()) {
                    if (container.getName().equals(containerName)) {
                        containerFound = true;
                        // 更新镜像名称
                        container.setImage(newImageName.trim());
                        log.debug("更新容器 '{}' 的镜像为: '{}'", containerName, newImageName);
                        break; // 找到并更新了容器，退出循环
                    }
                }

                if (!containerFound) {
                    return String.format("❌ Pod '%s' (命名空间: %s) 中未找到容器 '%s'。", podName, targetNamespace, containerName);
                }

                // 2. 应用修改后的 Pod 配置
                // 注意：修改镜像会触发 Pod 重建/重启。
                Pod updatedPod = client.pods().inNamespace(targetNamespace).resource(pod).patch();

                if (updatedPod != null) {
                    return String.format("✅ **成功更新 Pod '%s' (命名空间: %s) 中容器 '%s' 的镜像为 '%s'**。" +
                                    "Pod 将会重建/重启以尝试拉取新镜像，请观察 Pod 状态。",
                            podName, targetNamespace, containerName, newImageName);
                } else {
                    return String.format("❌ **未能成功更新 Pod '%s' (命名空间: %s) 中容器 '%s' 的镜像**。请检查 Pod 状态或权限。",
                            podName, targetNamespace, containerName);
                }

            }
        } catch (KubernetesClientException e) {
            log.error("修复 Pod {} 容器 {} 镜像拉取失败: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **修复 Pod '%s' 中容器 '%s' 镜像拉取失败**: %s", podName, containerName, e.getMessage());
        } catch (Exception e) {
            log.error("修复 Pod {} 容器 {} 镜像拉取时发生未知错误: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **修复 Pod '%s' 中容器 '%s' 镜像拉取时发生未知错误**: %s", podName, containerName, e.getMessage());
        }
    }

    /**
     * 根据Pod名称（模糊匹配）获取Pod所在的命名空间。
     * 如果找到多个同名Pod或部分匹配的Pod，会返回所有匹配Pod及其命名空间。
     * 如果没有指定命名空间，则在所有命名空间中查找。
     *
     * @param podName 要查找的Pod名称（支持部分匹配）。
     * @return 包含Pod名称和命名空间的列表字符串，如果找不到则返回提示信息。
     */
    @Tool(description = "根据Pod名称（支持部分匹配）获取Pod所在的命名空间，当你调用工具不知道pod的命名空间时可以优先使用。如果找到多个同名Pod，会返回所有匹配Pod及其命名空间。如果没有指定命名空间，则在所有命名空间中查找。")
    public String getPodNamespaceByName(String podName) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        log.info("🔍 尝试根据名称 '{}' 获取 Pod 的命名空间。", podName);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 信息。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                List<Pod> allPods = client.pods().inAnyNamespace().list().getItems();
                List<String> matchingPods = new java.util.ArrayList<>();

                for (Pod pod : allPods) {
                    if (pod.getMetadata() != null && pod.getMetadata().getName() != null &&
                            pod.getMetadata().getName().contains(podName.trim())) { // 使用 contains 进行模糊匹配
                        matchingPods.add(String.format("Pod: '%s', 命名空间: '%s'",
                                pod.getMetadata().getName(), pod.getMetadata().getNamespace()));
                    }
                }

                if (!matchingPods.isEmpty()) {
                    StringBuilder result = new StringBuilder();
                    result.append(String.format("✅ **找到以下匹配 Pod 名称 '%s' 的 Pod(s) 及其命名空间**:\n", podName));
                    for (String match : matchingPods) {
                        result.append("- ").append(match).append("\n");
                    }
                    return result.toString();
                } else {
                    return String.format("ℹ️ **未找到名称中包含 '%s' 的 Pod**。", podName);
                }

            }
        } catch (KubernetesClientException e) {
            log.error("根据 Pod 名称获取命名空间失败: {}", e.getMessage(), e);
            return String.format("❌ **根据 Pod 名称 '%s' 获取命名空间失败**: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("根据 Pod 名称获取命名空间时发生未知错误: {}", e.getMessage(), e);
            return String.format("❌ **根据 Pod 名称 '%s' 获取命名空间时发生未知错误**: %s", podName, e.getMessage());
        }
    }

    /**
     * 根据指定的标签（Label）获取Pod的名称和所在的命名空间。
     * 可以指定一个或多个标签，所有指定的标签都必须匹配Pod才会被返回。
     * 如果没有指定命名空间，则在所有命名空间中查找。
     *
     * @param labelKey 标签的键（例如 "app"）。
     * @param labelValue 标签的值（例如 "nginx"）。
     * @param namespace 可选参数，指定在哪个命名空间中查找，如果为null或空则在所有命名空间中查找。
     * @return 包含匹配Pod名称和命名空间的列表字符串，如果找不到则返回提示信息。
     */
    @Tool(description = "根据指定的标签（Label）获取Pod的名称和所在的命名空间，当你找不到pod时可以优先使用。可以指定一个或多个标签，所有指定的标签都必须匹配Pod才会被返回。")
    public String getPodNamesByLabel(String labelKey, String labelValue, String namespace) {
        if (labelKey == null || labelKey.trim().isEmpty() || labelValue == null || labelValue.trim().isEmpty()) {
            return "❌ **标签键和标签值都不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? null : namespace; // null 表示所有命名空间
        log.info("🔍 尝试根据标签 '{}:{}' 获取 Pod 名称。在命名空间: {}", labelKey, labelValue,
                targetNamespace != null ? targetNamespace : "所有命名空间");

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 信息。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                List<Pod> pods;

                if (targetNamespace != null) {
                    pods = client.pods().inNamespace(targetNamespace).withLabel(labelKey, labelValue).list().getItems();
                } else {
                    pods = client.pods().inAnyNamespace().withLabel(labelKey, labelValue).list().getItems();
                }

                if (pods != null && !pods.isEmpty()) {
                    StringBuilder result = new StringBuilder();
                    result.append(String.format("✅ **找到以下匹配标签 '%s:%s' 的 Pod(s)**:\n", labelKey, labelValue));
                    for (Pod pod : pods) {
                        result.append(String.format("- 名称: '%s', 命名空间: '%s'\n",
                                pod.getMetadata().getName(), pod.getMetadata().getNamespace()));
                    }
                    return result.toString();
                } else {
                    return String.format("ℹ️ **在命名空间 '%s' 中未找到标签 '%s:%s' 的 Pod**。",
                            targetNamespace != null ? targetNamespace : "所有命名空间", labelKey, labelValue);
                }

            }
        } catch (KubernetesClientException e) {
            log.error("根据标签获取 Pod 名称失败: {}", e.getMessage(), e);
            return String.format("❌ **根据标签 '%s:%s' 获取 Pod 名称失败**: %s", labelKey, labelValue, e.getMessage());
        } catch (Exception e) {
            log.error("根据标签获取 Pod 名称时发生未知错误: {}", e.getMessage(), e);
            return String.format("❌ **根据标签 '%s:%s' 获取 Pod 名称时发生未知错误**: %s", labelKey, labelValue, e.getMessage());
        }
    }

    /**
     * 根据给定的字符串，判断它最可能对应的是一个Pod名称、命名空间名称还是一个标签（key=value）。
     * 当AI不确定用户输入的名称类型时，可以调用此工具进行判断。
     *
     * @param name 要判断的字符串。
     * @return 描述该字符串类型的消息。
     */
    @Tool(description = "根据给定的字符串，判断它最可能对应的是一个Pod名称、命名空间名称还是一个标签（key=value）。当AI不确定用户输入的名称类型时，应调用此工具进行判断。")
    public String identifyKubernetesEntityType(String name) {
        if (name == null || name.trim().isEmpty()) {
            return "❌ **输入名称不能为空**。";
        }

        String trimmedName = name.trim();
        log.info("🤔 尝试识别 Kubernetes 实体类型: '{}'", trimmedName);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法识别实体类型。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 1. 尝试作为命名空间名称进行精确匹配
                io.fabric8.kubernetes.api.model.Namespace ns = client.namespaces().withName(trimmedName).get();
                if (ns != null) {
                    return String.format("✅ **'%s' 是一个有效的命名空间名称**。", trimmedName);
                }

                // 2. 尝试作为精确的 Pod 名称 (在任意命名空间中查找)
                // 由于 Fabric8 的 withName() 在 inAnyNamespace() 后需要明确上下文，
                // 更可靠的做法是列出所有 Pod 后再在内存中过滤。
                List<Pod> pods = client.pods().inAnyNamespace().list().getItems().stream()
                        .filter(p -> p.getMetadata() != null && trimmedName.equals(p.getMetadata().getName()))
                        .collect(java.util.stream.Collectors.toList());
                if (!pods.isEmpty()) {
                    if (pods.size() == 1) {
                        return String.format("✅ **'%s' 是一个有效的 Pod 名称** (位于命名空间: '%s')。", trimmedName, pods.get(0).getMetadata().getNamespace());
                    } else {
                        // 如果有多个相同名称的 Pod 存在于不同命名空间
                        StringBuilder sb = new StringBuilder();
                        sb.append(String.format("✅ **'%s' 是一个有效的 Pod 名称，但存在于多个命名空间**:\n", trimmedName));
                        for (Pod p : pods) {
                            sb.append(String.format("- 命名空间: '%s'\n", p.getMetadata().getNamespace()));
                        }
                        return sb.toString();
                    }
                }

                // 3. 尝试作为 "labelKey=labelValue" 形式的标签
                if (trimmedName.contains("=")) {
                    String[] parts = trimmedName.split("=", 2); // 只分割一次，处理值中包含等号的情况
                    if (parts.length == 2 && !parts[0].trim().isEmpty() && !parts[1].trim().isEmpty()) {
                        String labelKey = parts[0].trim();
                        String labelValue = parts[1].trim();

                        List<Pod> labeledPods = client.pods().inAnyNamespace().withLabel(labelKey, labelValue).list().getItems();
                        if (!labeledPods.isEmpty()) {
                            return String.format("✅ **'%s' 是一个有效的标签 (Label: '%s=%s')，并且找到了匹配该标签的 Pods**。", trimmedName, labelKey, labelValue);
                        } else {
                            // 可能是有效的标签形式，但没有匹配的Pod
                            return String.format("ℹ️ **'%s' 是一个标签形式 (Label: '%s=%s')，但未找到匹配该标签的 Pods**。", trimmedName, labelKey, labelValue);
                        }
                    }
                }

                // 4. 其他情况：无法明确识别
                // 此时，它可以是部分 Pod 名称 (需要模糊搜索), 或者其他 Kubernetes 资源名称，或者是一个没有匹配到任何 Pod 的标签键或值。
                return String.format("❓ **无法明确识别 '%s' 的类型**。它可能是一个部分 Pod 名称、其他 Kubernetes 资源名称，或者是一个没有匹配到任何 Pod 的标签。您是否需要更具体的帮助？", trimmedName);

            }
        } catch (KubernetesClientException e) {
            log.error("识别实体类型 '{}' 失败: {}", trimmedName, e.getMessage(), e);
            return String.format("❌ **识别实体类型 '%s' 失败**: %s", trimmedName, e.getMessage());
        } catch (Exception e) {
            log.error("识别实体类型 '{}' 时发生未知错误: {}", trimmedName, e.getMessage(), e);
            return String.format("❌ **识别实体类型 '%s' 时发生未知错误**: %s", trimmedName, e.getMessage());
        }
    }

    // 辅助方法：格式化探针的详细信息
    private String formatProbeDetails(Probe probe) {
        StringBuilder details = new StringBuilder();
        if (probe.getHttpGet() != null) {
            details.append(String.format("    - 类型: HTTP GET (%s:%d%s)\n",
                    probe.getHttpGet().getHost() != null ? probe.getHttpGet().getHost() : "Pod IP",
                    probe.getHttpGet().getPort() != null ? probe.getHttpGet().getPort().getIntVal() : "N/A",
                    probe.getHttpGet().getPath() != null ? probe.getHttpGet().getPath() : "/"));
        } else if (probe.getExec() != null) {
            details.append(String.format("    - 类型: EXEC (命令: %s)\n", String.join(" ", probe.getExec().getCommand())));
        } else if (probe.getTcpSocket() != null) {
            details.append(String.format("    - 类型: TCP Socket (%s:%d)\n",
                    probe.getTcpSocket().getHost() != null ? probe.getTcpSocket().getHost() : "Pod IP",
                    probe.getTcpSocket().getPort() != null ? probe.getTcpSocket().getPort().getIntVal() : "N/A"));
        }
        details.append(String.format("    - 初始延迟 (initialDelaySeconds): %d 秒\n", probe.getInitialDelaySeconds() != null ? probe.getInitialDelaySeconds() : 0));
        details.append(String.format("    - 周期 (periodSeconds): %d 秒\n", probe.getPeriodSeconds() != null ? probe.getPeriodSeconds() : 10));
        details.append(String.format("    - 超时 (timeoutSeconds): %d 秒\n", probe.getTimeoutSeconds() != null ? probe.getTimeoutSeconds() : 1));
        details.append(String.format("    - 成功阈值 (successThreshold): %d 次\n", probe.getSuccessThreshold() != null ? probe.getSuccessThreshold() : 1));
        details.append(String.format("    - 失败阈值 (failureThreshold): %d 次\n", probe.getFailureThreshold() != null ? probe.getFailureThreshold() : 3));
        return details.toString();
    }

    // 辅助方法：解析 CPU Quantity (例如 "100m" -> 100 * 10^6 nanoseconds, "1" -> 10^9 nanoseconds)
    private double parseCpuQuantity(String quantity) {
        if (quantity == null || quantity.isEmpty()) return 0;
        if (quantity.endsWith("m")) { // milli-cores
            return Double.parseDouble(quantity.substring(0, quantity.length() - 1)) * 1_000_000; // to nano-cores
        } else { // cores
            return Double.parseDouble(quantity) * 1_000_000_000; // to nano-cores
        }
    }

    // 辅助方法：解析 Memory Quantity (例如 "100Mi" -> bytes, "1G" -> bytes)
    private double parseMemoryQuantity(String quantity) {
        if (quantity == null || quantity.isEmpty()) return 0;
        quantity = quantity.toUpperCase();
        if (quantity.endsWith("K") || quantity.endsWith("KI")) {
            return Double.parseDouble(quantity.substring(0, quantity.length() - (quantity.endsWith("I") ? 2 : 1))) * 1024;
        } else if (quantity.endsWith("M") || quantity.endsWith("MI")) {
            return Double.parseDouble(quantity.substring(0, quantity.length() - (quantity.endsWith("I") ? 2 : 1))) * 1024 * 1024;
        } else if (quantity.endsWith("G") || quantity.endsWith("GI")) {
            return Double.parseDouble(quantity.substring(0, quantity.length() - (quantity.endsWith("I") ? 2 : 1))) * 1024 * 1024 * 1024;
        } else if (quantity.endsWith("T") || quantity.endsWith("TI")) {
            return Double.parseDouble(quantity.substring(0, quantity.length() - (quantity.endsWith("I") ? 2 : 1))) * 1024L * 1024 * 1024 * 1024;
        } else { // assume bytes if no unit
            return Double.parseDouble(quantity);
        }
    }

    // 辅助方法：格式化字节数
    private String formatBytes(double bytes) {
        if (bytes < 1024) return String.format("%.2f B", bytes);
        double kb = bytes / 1024;
        if (kb < 1024) return String.format("%.2f KB", kb);
        double mb = kb / 1024;
        if (mb < 1024) return String.format("%.2f MB", mb);
        double gb = mb / 1024;
        return String.format("%.2f GB", gb);
    }

    // 辅助方法：将 CPU Quantity 转换为更易读的格式
    private String convertCpuUnit(String cpuQuantity) {
        if (cpuQuantity == null || cpuQuantity.isEmpty() || "N/A".equals(cpuQuantity)) {
            return "N/A";
        }
        try {
            if (cpuQuantity.endsWith("n")) { // nano-cores (e.g., "123456789n")
                double nanoCores = Double.parseDouble(cpuQuantity.substring(0, cpuQuantity.length() - 1));
                return String.format("%.3f cores", nanoCores / 1_000_000_000.0);
            } else if (cpuQuantity.endsWith("m")) { // milli-cores (e.g., "100m")
                double milliCores = Double.parseDouble(cpuQuantity.substring(0, cpuQuantity.length() - 1));
                return String.format("%.3f cores", milliCores / 1000.0);
            } else { // raw cores (e.g., "1", "0.5")
                double cores = Double.parseDouble(cpuQuantity);
                return String.format("%.3f cores", cores);
            }
        } catch (NumberFormatException e) {
            return cpuQuantity; // 返回原始字符串如果解析失败
        }
    }

    // 辅助方法：将 Memory Quantity 转换为更易读的格式
    private String convertMemoryUnit(String memoryQuantity) {
        if (memoryQuantity == null || memoryQuantity.isEmpty() || "N/A".equals(memoryQuantity)) {
            return "N/A";
        }
        memoryQuantity = memoryQuantity.toUpperCase();
        try {
            if (memoryQuantity.endsWith("KI")) {
                return String.format("%.2f KB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 2)));
            } else if (memoryQuantity.endsWith("MI")) {
                return String.format("%.2f MB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 2)));
            } else if (memoryQuantity.endsWith("GI")) {
                return String.format("%.2f GB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 2)));
            } else if (memoryQuantity.endsWith("TI")) {
                return String.format("%.2f TB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 2)));
            } else if (memoryQuantity.endsWith("K")) {
                return String.format("%.2f KB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 1)));
            } else if (memoryQuantity.endsWith("M")) {
                return String.format("%.2f MB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 1)));
            } else if (memoryQuantity.endsWith("G")) {
                return String.format("%.2f GB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 1)));
            } else if (memoryQuantity.endsWith("T")) {
                return String.format("%.2f TB", Double.parseDouble(memoryQuantity.substring(0, memoryQuantity.length() - 1)));
            } else { // Assume bytes
                double bytes = Double.parseDouble(memoryQuantity);
                return formatBytes(bytes);
            }
        } catch (NumberFormatException e) {
            return memoryQuantity; // 返回原始字符串如果解析失败
        }
    }

    // 辅助方法
    private boolean isPodHealthy(Pod pod) {
        String phase = pod.getStatus().getPhase();
        if (!"Running".equals(phase) && !"Succeeded".equals(phase)) {
            return false;
        }

        String readyStatus = getPodReadyStatus(pod);
        if ("False".equals(readyStatus)) {
            return false;
        }

        int restartCount = getRestartCount(pod);
        return restartCount < 10; // 重启次数超过10次认为不健康
    }

    private int getProblemScore(Pod pod) {
        String phase = pod.getStatus().getPhase();
        int restartCount = getRestartCount(pod);
        String readyStatus = getPodReadyStatus(pod);

        int score = 0;
        if ("Failed".equals(phase)) score += 100;
        else if ("Pending".equals(phase)) score += 50;
        else if ("False".equals(readyStatus)) score += 30;

        score += Math.min(restartCount, 50); // 重启次数，最多加50分

        return score;
    }

    private String getProblemSeverity(Pod pod) {
        int score = getProblemScore(pod);
        if (score >= 100) return "🔴 严重";
        else if (score >= 50) return "🟡 中等";
        else return "🟢 轻微";
    }

    private String getRecommendation(Pod pod) {
        String phase = pod.getStatus().getPhase();
        int restartCount = getRestartCount(pod);

        if ("Failed".equals(phase)) {
            return "检查Pod详情和日志，可能需要重新部署";
        } else if ("Pending".equals(phase)) {
            return "检查资源配额和调度条件";
        } else if (restartCount > 10) {
            return "检查应用日志，可能存在应用级别问题";
        } else {
            return "检查Pod状态和就绪性探针";
        }
    }

    private int getRestartCount(Pod pod) {
        return pod.getStatus().getContainerStatuses() != null ?
                pod.getStatus().getContainerStatuses().stream()
                        .mapToInt(cs -> cs.getRestartCount() != null ? cs.getRestartCount() : 0)
                        .sum() : 0;
    }

    private String getPodReadyStatus(Pod pod) {
        try {
            if (pod.getStatus().getConditions() != null) {
                return pod.getStatus().getConditions().stream()
                        .filter(condition -> "Ready".equals(condition.getType()))
                        .findFirst()
                        .map(condition -> condition.getStatus())
                        .orElse("Unknown");
            }
            return "Unknown";
        } catch (Exception e) {
            return "Error";
        }
    }
}
